/**
 * form表单规则工具
 *
 * 使用：
 * mRules = {
 *            id: [RuleKit.notNullBlur("不能为空"), RuleKit.notNullChange("不能为空")],
 *            name: [RuleKit.notNullBlur("不能为空")],
 *        };
 */
import {validate} from "@/core/utils/validate";
import {isBlank} from "@/core/utils/Utils";

// 单独验证某个字段 或 某几个字段
// (this.$refs.form as ElForm).validateField("prop" | ['prop1','prop2']);
class Rule {
    notNullBlur(message: any = '不能为空') {
        return {required: true, message: message, trigger: 'blur'};
    }

    notNullChange(message: any = '不能为空') {
        return {required: true, message: message, trigger: 'change'};
    }

    length(min: number, max: number) {
        return {
            required: true,
            validator: (rule: any, value: any, callback: any) => {
                if (value == 0) {
                    callback()
                    return
                }

                if (!value || value.length < min) {
                    callback(new Error('最小长度为 ' + min + ' 个字符'))
                } else if (value.length > max) {
                    callback(new Error('最大长度为 ' + max + ' 个字符'))
                } else {
                    callback()
                }
            }, trigger: 'blur'
        }
    }

    /**
     * 带 new的调整的以后的项目中使用
     * @param min 最小长度
     * @param max 最大长度
     * @param required 可选true、false
     * @param trigger 可选change、blur
     */
    length_new(min: number, max: number, required: boolean = true, trigger: string = 'blur') {
        return {
            required: required,
            validator: (rule: any, value: any, callback: any) => {
                if (value == 0) {
                    callback()
                    return
                }

                if (!value || value.length < min) {
                    callback(new Error('最小长度为 ' + min + ' 个字符'))
                } else if (value.length > max) {
                    callback(new Error('最大长度为 ' + max + ' 个字符'))
                } else {
                    callback()
                }
            }, trigger: trigger
        }
    }


    lengthReqFalse(min: number, max: number) {
        return {
            required: false,
            validator: (rule: any, value: any, callback: any) => {
                if (!value || value == 0) {
                    callback();
                    return;
                }

                if (value.length < min) {
                    callback(new Error('最小长度为 ' + min + ' 个字符'))
                } else if (value.length > max) {
                    callback(new Error('最大长度为 ' + max + ' 个字符'))
                } else {
                    callback()
                }
            }, trigger: 'blur'
        }
    }

    /**
     * 动态人力资源信息校验规则
     * 月末从业人员数 = 上月末从业人员数 + 本期实际招工人员数 - 本月减员人员数
     * @param thisMonthEndWorkCount  月末从业人员数
     * @param beforeMonthEndWorkCount  上月末从业人员数
     * @param realWorkCount  本期实际招工人员数
     * @param thisMonthLessCount  本月减员人员数
     */
    formulaValidator1(thisMonthEndWorkCount: number, beforeMonthEndWorkCount: number, realWorkCount: number, thisMonthLessCount: number) {
        return {
            required: false,
            message: "",
            validator: (rule: any, value: any, callback: any) => {
                if (thisMonthEndWorkCount != beforeMonthEndWorkCount + realWorkCount - thisMonthLessCount) {
                    callback(new Error('月末从业人员数 = 上月末从业人员数 + 本期实际招工人员数 - 本月减员人员数'));
                } else {
                    callback();
                }
            }, trigger: 'change'
        }
    }

    /**
     * 动态人力资源信息校验规则
     * 本月缺工人数  = 期望招工人数 - 本期实际招工人员数
     * （期望招工人数 - 本期实际招工人员数）小于0且本月缺工等于0时---校验通过
     * @param thisMonthLackCount  本月缺工人数
     * @param expectWorkCount  期望招工人数
     * @param realWorkCount  本期实际招工人员数
     */
    formulaValidator2(thisMonthLackCount: number, expectWorkCount: number, realWorkCount: number) {
        return {
            required: false,
            message: "",
            validator: (rule: any, value: any, callback: any) => {
                //小于0时 返回0
                if (expectWorkCount - realWorkCount <= 0 && thisMonthLackCount == 0) {
                    callback();
                    return;
                }
                if (thisMonthLackCount != expectWorkCount - realWorkCount) {
                    callback(new Error('本月缺工人数  = 期望招工人数 - 本期实际招工人员数'));
                } else {
                    callback();
                }
            }, trigger: 'change'
        }
    }


    /**
     * 必须输入两位小数
     */
    twoDecimalPlaces = {
        required: true,
        validator: (rule: any, value: any, callback: any) => {
            if (!value || value == "") return callback(new Error('概率不能为空'));
            if (!validate.zeroTwoPlaces(value)) {
                return callback(new Error('请输入大于0小于1的小数 例:0.01'));
            }
            callback();
        }, trigger: 'blur'
    };

    //手机格式
    phone11 = {
        required: true, validator: (rule: any, value: any, callback: any) => {
            if (!validate.isPhone(value)) return callback(new Error('手机号格式错误'));
            callback();
        }, trigger: 'blur'
    };

    // 固定电话格式 区号3-4位加-加号码7-8位 有无区号都可
    telephone78 = {
        required: true, validator: (rule: any, value: any, callback: any) => {
            if (!validate.isTelephone(value)) return callback(new Error('固定电话格式错误，区号使用-隔开，号码为7-8位'));
            callback();
        }, trigger: 'blur'
    };

    account = {
        required: true,
        validator: (rule: any, value: any, callback: any) => {
            if (!value || value == "") return callback(new Error('账号不能为空'));
            if (!validate.checkAccount(value)) {
                return callback(new Error('请输入账号,6到20位,可以包含（字母，数字，下划线）'));
            }
            callback();
        }, trigger: 'blur'
    };

    password = {
        required: true,
        validator: (rule: any, value: any, callback: any) => {
            if (!value || value == "") return callback(new Error('密码不能为空'));
            if (!validate.checkPassword(value)) {
                return callback(new Error('请输入密码8到16位,可以包含（字母，数字，下划线）'));
            }
            callback();
        }, trigger: 'blur'
    };

}

export const rule = new Rule();
